/**
 * API服务模块 - 处理与后端的网络请求
 */
import fetch from '@system.fetch';
import storage from '@system.storage';

// API基础URL
const BASE_URL = 'http://39.106.45.98:3002';

// 请求超时时间(ms)
const TIMEOUT = 10000;

// 存储键名
const TOKEN_KEY = 'user_token';
const USER_ID_KEY = 'user_id';

/**
 * 发送GET请求
 * @param {string} endpoint - API端点
 * @param {Object} params - URL参数
 * @returns {Promise} 返回请求Promise
 */
export function get(endpoint, params = {}) {
    return request(endpoint, 'GET', params);
}

/**
 * 发送POST请求
 * @param {string} endpoint - API端点
 * @param {Object} data - 请求体数据
 * @returns {Promise} 返回请求Promise
 */
export function post(endpoint, data = {}) {
    return request(endpoint, 'POST', data);
}

/**
 * 通用请求方法
 * @param {string} endpoint - API端点
 * @param {string} method - 请求方法(GET/POST)
 * @param {Object} data - 请求数据
 * @returns {Promise} 返回请求Promise
 */
async function request(endpoint, method, data) {
    try {
        // 构建URL
        let url = BASE_URL + endpoint;
        
        // 对于GET请求，将参数附加到URL
        if (method === 'GET' && Object.keys(data).length > 0) {
            const queryParams = Object.keys(data)
                .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
                .join('&');
            url += `?${queryParams}`;
        }
        
        // 获取用户令牌
        const token = await storage.get({
            key: TOKEN_KEY,
            default: ''
        });
        
        // 准备请求选项
        const options = {
            url: url,
            method: method,
            responseType: 'json',
            header: {
                'Content-Type': 'application/json'
            },
            timeout: TIMEOUT
        };
        
        // 添加令牌到请求头(如果有)
        if (token && token.trim() !== '') {
            options.header['Authorization'] = `Bearer ${token}`;
        }
        
        // 对于POST请求，添加请求体
        if (method === 'POST') {
            options.data = JSON.stringify(data);
        }
        
        console.info(`发送${method}请求: ${url}`);
        
        // 发送请求
        return new Promise((resolve, reject) => {
            fetch.fetch({
                ...options,
                success: (response) => {
                    console.info(`请求成功: ${response.code}`);
                    if (response.code === 200) {
                        let result;
                        try {
                            // 解析响应
                            if (typeof response.data === 'string') {
                                result = JSON.parse(response.data);
                            } else {
                                result = response.data;
                            }
                            resolve(result);
                        } catch (error) {
                            console.error('解析响应失败:', error);
                            reject(new Error('解析响应失败'));
                        }
                    } else {
                        console.error(`请求失败，状态码: ${response.code}`);
                        reject(new Error(`请求失败，状态码: ${response.code}`));
                    }
                },
                fail: (error) => {
                    console.error('请求失败:', error);
                    reject(error);
                }
            });
        });
    } catch (error) {
        console.error('请求处理失败:', error);
        throw error;
    }
}

/**
 * 保存用户认证信息
 * @param {string} token - 用户令牌
 * @param {number} userId - 用户ID
 */
export function saveAuthInfo(token, userId) {
    storage.set({
        key: TOKEN_KEY,
        value: token
    });
    
    storage.set({
        key: USER_ID_KEY,
        value: userId.toString()
    });
}

/**
 * 清除用户认证信息
 */
export function clearAuthInfo() {
    storage.delete({
        key: TOKEN_KEY
    });
    
    storage.delete({
        key: USER_ID_KEY
    });
}

/**
 * 获取用户ID
 * @returns {Promise<number>} 用户ID
 */
export async function getUserId() {
    try {
        const userId = await storage.get({
            key: USER_ID_KEY,
            default: '0'
        });
        
        return parseInt(userId);
    } catch (error) {
        console.error('获取用户ID失败:', error);
        return 0;
    }
}

/**
 * 检查用户是否已登录
 * @returns {Promise<boolean>} 是否已登录
 */
export async function isAuthenticated() {
    try {
        const token = await storage.get({
            key: TOKEN_KEY,
            default: ''
        });
        
        return token && token.trim() !== '';
    } catch (error) {
        console.error('检查认证状态失败:', error);
        return false;
    }
}

/**
 * 获取网络状态
 * @returns {Promise<boolean>} 是否连接网络
 */
export function getNetworkStatus() {
    return new Promise((resolve) => {
        // 检查网络连接(简单测试请求)
        fetch.fetch({
            url: BASE_URL,
            method: 'HEAD',
            timeout: 3000,
            success: () => {
                resolve(true);
            },
            fail: () => {
                resolve(false);
            }
        });
    });
} 